package com.caits.lbs.framework.services.redis;

import java.io.Serializable;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * RedisCacheHelper
 * 使用spring-redis操作Redis工具类,在进行扩展时请仿照原有功能进行扩展
 * @author zhangzhiheng
 * @date 17/1/12
 */
public interface RedisDAO {
	/**
     * 发送消息
     *
     * @param channel 通道名称
     * @param message 消息对象
     *                void
     */
    void sendMessage(String channel, Serializable message);

    long lpush(String key, Object obj);

    long rpush(String key, Object obj);

    String lpop(String key);

    String bLPop(final int timeOut, final String key);
    long ltrim(String key,int start,int stop);
    <T> List<T> lrange(String key,int start,int stop, Class<T> clazz);
    long llen(String key);
    
    
    /**
     * Key操作,判断key是否存在
     *
     * @param key
     * @return
     */
    public Boolean exists(String key);


    /**
     * Key操作，SET if Not eXists
     * @param key
     * @param value
     * @param seconds
     * @return
     */
    public Boolean setnx(String key, String value);

    /**
	 * 不存在则写入值 
	 * @param key
	 * @param value
	 * @param expireTime
	 * @return
	 */
	Boolean setnx(final String key, final String value, int expireTime);
    /**
     * 通过setnx设置的值通过该方法获取
     * @param key
     * @return
     */
    public String getString(String key);


    /**
     * Key操作,设置一个key的过期时间
     *
     * @param key
     * @param seconds
     * @return
     */
    public Boolean expire(String key, long seconds);


    /**
     * Key操作,获取指定key值的剩余生存时间
     *
     * @param key
     * @return
     */
    public Long getExpireTime(String key);


    /**
     * Key操作,删除缓存
     *
     * @param key
     * @return
     */
    public Long delCache(String key);

    /**
     * String操作,根据key值进行自增
     *
     * @param key
     * @param n
     * @return
     */
    public Long incr(String key, Long n);


    /**
     * String操作,新增缓存
     *
     * @param key
     * @param obj
     * @param seconds 过期时间
     */
    public void addCache(String key, Object obj, long seconds);


    /**
     * String操作,获取缓存
     *
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T getCache(String key, Class<T> clazz);

    <T> T getCache(String key, Type clazz);
    /**
     * Hash操作，添加hash
     * @param key
     * @param map
     * @param seconds
     */
    public <V> void hAdd(String key, Map<String,V> map, long seconds);


    /**
     * Hash操作，获取所有键值对
     * @param key
     * @return
     */
    public <V> Map<String,V> hGetAll(String key, Class<V> vClass);

    /**
     * Hash操作,获取hashMap指定字段的值
     *
     * @param key
     * @param key2
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T hGet(String key, String key2, Class<T> clazz);

    /**
     * Hash操作,设置hashMap值
     *
     * @param key
     * @param key2
     * @param obj
     */
    public void hSet(String key, String key2, Object obj);


    /**
     * Hash操作,对hashMap指定字段增加incr
     *
     * @param key
     * @param key2
     * @param incr
     * @return
     */
    public Long hIncrBy(String key, String key2, long incr);

    /**
     * Hash操作,删除hashMap指定字段
     *
     * @param key
     * @param key2
     */
    public void hDel(String key, String key2);

    /**
     * Hash操作,判断hashMap中是否包含某个key
     *
     * @param key
     * @param key2
     * @return
     */
    public Boolean hExists(String key, String key2);


    /**
     * List操作,执行redis的lpush命令
     *
     * @param key
     * @param lists
     * @param seconds
     * @param <T>
     */
    public <T> void addListCache(final String key, final List<T> lists, final Long seconds);


    /**
     * List操作,执行redis的rpush命令
     * @param key
     * @param lists
     * @param seconds
     * @param <T>
     */
    public <T> void addListCacheRight(final String key, final List<T> lists, final long seconds);


    /**
     * List操作,执行redis的rpush命令
     * @param key
     * @param t
     * @param seconds
     * @param <T>
     */
    public <T> void addListCacheRight(final String key, final T t, final long seconds);

    /**
     * List操作,删除List中value=t的所有元素
     * @param key
     * @param t
     * @param <T>
     */
    public <T> void delListCache(final String key, final T t);

    /**
     * List操作,获取list缓存
     *
     * @param key
     * @param clazz
     * @param <E>
     * @return
     */
    public <E> List<E> getListCache(String key, Class<E> clazz);


    /**
     * List操作，对list进行修剪，保留start~stop的元素
     * @param key
     * @param start
     * @param stop
     */
    public void listTrim(String key, int start, int stop);


    /**
     * Set操作,添加set缓存
     *
     * @param key
     * @param sets
     * @param seconds
     */
    public void addSetCache(final String key, final Set<?> sets, final Long seconds);

    /**
     * Set操作,获取set集合
     *
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> Set<T> getSetCache(String key, Class<T> clazz);

    /**
     * Set操作,向set集合中添加元素
     *
     * @param key
     * @param value
     * @param seconds
     */
    public void sAdd(final String key, final Object value, final Long seconds);

    /**
     * Set操作,移除set中指定值
     *
     * @param key
     * @param value
     * @return
     */
    public Long sRem(final String key, final Object value);


    /**
     * SortedSet操作，增加一个对象到key里
     *
     * @param key
     * @param value
     * @param time
     */
    void zAdd(final String key, final Object value,
              final Long time);

    /**
     * SortedSet操作，移除一个对象从key里
     *
     * @param key
     * @param value
     */
    Long zRem(final String key, final Object value);

    /**
     * SortedSet操作，获取指定个数的对象从key里
     *
     * @param key
     * @param value
     * @param time
     */
    <T> Set<T> zRange(String key, int from, int to, final Class<T> clazz);

    /**
     * SortedSet操作,删除指定元素
     *
     * @param key
     * @param value
     */
    void zRemSet(final String key, final Set<?> value);

    /**
     * SortedSet操作，获取元素个数
     *
     * @param key
     * @return
     */
    Long zCard(final String key);

    /**
     * SortedSet操作，在指定member上增加指定分值
     *
     * @param key
     * @param score
     * @param member
     * @return
     */
    Double zIncrBy(String key, double score, String member);

    /**
     * SortedSet操作，移除排名在start和end之间的所有元素
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    Long zRemRangeByRank(String key, long start, long end);

    /**
     * SortedSet操作，返回排名介于start和end间所有值和得分
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    Map<String, Double> zRangeWithScores(String key, long start, long end);

    /**
     * Key操作，监控某个key是否改变
     * @param key
     */
    void watch(String key);

    /**
     * Key操作，取消所有监控
     */
    void unwatch();

    /**
     * Redis事务，事务开始
     */
    void multi();

    /**
     * Redis事务，事务执行
     */
    void exec();

    /**
     * Redis事务，清除事务队列，取消事务
     */
    void discard();
}
